package com.promise.jokerdream.task

import com.promise.jokerdream.task.base.ITask
import com.promise.jokerdream.task.base.TaskResult
import com.promise.jokerdream.task.base.TaskStatus
import com.promise.jokerdream.task.base.TaskType
import kotlinx.coroutines.*
import java.time.LocalDateTime
import java.util.concurrent.ConcurrentHashMap

/**
 * 任务管理器 - 基于 TaskGroup 的实现
 */
class TaskManager {
    private val taskGroups = ConcurrentHashMap<String, TaskGroup>()
    private val defaultGroup = TaskGroup(groupName = "default")
    private val globalScope = CoroutineScope(Dispatchers.Default + SupervisorJob())
    private var schedulerStarted = false
    
    init {
        // 添加默认任务组
        taskGroups[defaultGroup.groupId] = defaultGroup
        // 启动全局定时器
        startGlobalScheduler()
    }
    
    /**
     * 创建新的任务组
     */
    fun createTaskGroup(groupName: String): String {
        val taskGroup = TaskGroup(groupName = groupName)
        taskGroups[taskGroup.groupId] = taskGroup
        return taskGroup.groupId
    }
    
    /**
     * 获取任务组
     */
    fun getTaskGroup(groupId: String): TaskGroup? {
        return taskGroups[groupId]
    }
    
    /**
     * 获取所有任务组
     */
    fun getAllTaskGroups(): List<TaskGroup> {
        return taskGroups.values.toList()
    }
    
    /**
     * 删除任务组
     */
    fun removeTaskGroup(groupId: String): Boolean {
        if (groupId == defaultGroup.groupId) {
            return false // 不能删除默认组
        }
        val group = taskGroups[groupId]
        group?.destroy()
        return taskGroups.remove(groupId) != null
    }
    
    /**
     * 添加任务到指定组（如果不指定组，则添加到默认组）
     */
    fun addTask(task: ITask, groupId: String? = null): Boolean {
        val targetGroup = if (groupId != null) {
            taskGroups[groupId] ?: return false
        } else {
            defaultGroup
        }
        return targetGroup.addTask(task)
    }
    
    /**
     * 从所有组中移除任务
     */
    fun removeTask(taskId: String): Boolean {
        var removed = false
        taskGroups.values.forEach { group ->
            val task = group.removeTask(taskId)
            if (task != null) {
                removed = true
            }
        }
        return removed
    }
    
    /**
     * 从所有组中查找任务
     */
    fun getTask(taskId: String): ITask? {
        taskGroups.values.forEach { group ->
            val task = group.getTask(taskId)
            if (task != null) return task
        }
        return null
    }
    
    /**
     * 根据类型从所有组中获取任务
     */
    fun getTasksByType(taskType: TaskType): List<ITask> {
        return taskGroups.values.flatMap { group ->
            group.getTasksByType(taskType)
        }
    }
    
    /**
     * 根据状态从所有组中获取任务
     */
    fun getTasksByStatus(status: TaskStatus): List<ITask> {
        return taskGroups.values.flatMap { group ->
            group.getTasksByStatus(status)
        }
    }
    
    /**
     * 执行立即任务（添加到指定组）
     */
    suspend fun executeImmediate(
        name: String, 
        repeatCount: Int = 1,
        groupId: String? = null,
        networkAction: suspend () -> Unit
    ): TaskResult {
        val task = ImmediateTask(name, repeatCount, networkAction)
        addTask(task, groupId)
        return task.execute()
    }
    
    /**
     * 调度定时任务（添加到指定组）
     */
    fun scheduleTask(
        name: String, 
        scheduledTime: LocalDateTime, 
        repeatCount: Int = 1,
        groupId: String? = null,
        networkAction: suspend () -> Unit
    ): String {
        val task = ScheduledTask.create(name, scheduledTime, repeatCount, networkAction)
        addTask(task, groupId)
        
        // 全局定时器会自动检查并执行到期的任务
        return task.id
    }

    /**
     * 执行指定组的所有立即任务
     */
    suspend fun executeGroupImmediateTasks(groupId: String): List<TaskResult> {
        val group = taskGroups[groupId] ?: return emptyList()
        return group.executeImmediateTasks()
    }
    
    
    /**
     * 取消任务
     */
    fun cancelTask(taskId: String): Boolean {
        taskGroups.values.forEach { group ->
            if (group.cancelTask(taskId)) {
                return true
            }
        }
        return false
    }
    
    /**
     * 取消指定组的所有任务
     */
    fun cancelGroupTasks(groupId: String): Boolean {
        val group = taskGroups[groupId] ?: return false
        group.cancelAllTasks()
        return true
    }
    
    /**
     * 取消所有任务
     */
    fun cancelAllTasks() {
        taskGroups.values.forEach { it.cancelAllTasks() }
    }
    
    /**
     * 重置指定组的所有任务
     */
    fun resetGroupTasks(groupId: String): Boolean {
        val group = taskGroups[groupId] ?: return false
        group.resetAllTasks()
        return true
    }
    
    /**
     * 获取任务统计信息（所有组的汇总）
     */
    fun getTaskStats(): AllTaskStats {
        val allGroupStats = taskGroups.values.map { it.getStats() }
        return AllTaskStats(
            total = allGroupStats.sumOf { it.total },
            success = allGroupStats.sumOf { it.success },
            failure = allGroupStats.sumOf { it.failure }
        )
    }
    
    /**
     * 获取所有任务组的统计信息
     */
    fun getAllGroupStats(): List<TaskGroupStats> {
        return taskGroups.values.map { it.getStats() }
    }
    
    /**
     * 获取指定组的统计信息
     */
    fun getGroupStats(groupId: String): TaskGroupStats? {
        return taskGroups[groupId]?.getStats()
    }
    
    /**
     * 清理已完成和已取消的任务（所有组）
     */
    fun cleanup() {
        taskGroups.values.forEach { it.cleanup() }
    }
    
    /**
     * 清理指定组的已完成和已取消任务
     */
    fun cleanupGroup(groupId: String): Boolean {
        val group = taskGroups[groupId] ?: return false
        group.cleanup()
        return true
    }
    
    /**
     * 等待指定组的所有任务完成
     */
    suspend fun awaitGroupCompletion(groupId: String): Boolean {
        val group = taskGroups[groupId] ?: return false
        group.awaitCompletion()
        return true
    }
    
    /**
     * 启动全局定时器轮询（每5秒钟检查一次）
     */
    private fun startGlobalScheduler() {
        if (schedulerStarted) return
        
        schedulerStarted = true
        globalScope.launch {
            while (globalScope.isActive) {
                try {
                    // 检查所有任务组中的定时任务
                    taskGroups.values.forEach { group ->
                        val scheduledTasks = group.getTasksByType(TaskType.SCHEDULED)
                        val tasksToRemove = mutableListOf<String>()
                        
                        scheduledTasks.forEach { task ->
                            if (task is ScheduledTask && task.isTimeToExecute) {
                                // 执行到期的任务
                                globalScope.launch {
                                    try {
                                        println("执行定时任务: ${task.name}")
                                        val result = task.execute()
                                        
                                        // 检查任务是否已完成
                                        if (task.isCompleted || task.getStatus() == TaskStatus.COMPLETED) {
                                            // 任务完成后从组中移除
                                            group.removeTask(task.id)
                                            println("定时任务已完成并移除: ${task.name}")
                                        }
                                        
                                    } catch (e: Exception) {
                                        // 任务执行失败，记录日志但不影响其他任务
                                        println("定时任务执行失败: ${task.name}, 错误: ${e.message}")
                                        // 失败的任务也应该被移除，避免重复执行
                                        group.removeTask(task.id)
                                    }
                                }
                            }
                        }
                    }
                    
                    // 等待5秒
                    delay(5_000) // 5秒
                } catch (e: Exception) {
                    // 定时器异常，记录日志但继续运行
                    println("全局定时器异常: ${e.message}")
                    delay(5_000) // 继续等待5秒
                }
            }
        }
    }
    
    /**
     * 销毁任务管理器
     */
    fun destroy() {
        taskGroups.values.forEach { it.destroy() }
        taskGroups.clear()
        globalScope.cancel()
    }
}

/**
 * 任务统计信息
 */
data class AllTaskStats(
    val total: Int,
    val success: Int,
    val failure: Int
)

/**
 * 全局任务管理器实例
 */
object GlobalTaskManager {
    private val instance = TaskManager()
    
    fun getInstance(): TaskManager = instance
}
